package collect

import (
	"fmt"
	"huijing_mall/internal/cachebase"
	"huijing_mall/internal/database/models"
	"huijing_mall/logic/collectlogic"
	"huijing_mall/pkg/logger"
	"huijing_mall/shared/common"
	"huijing_mall/shared/get_ctx_value"
	"huijing_mall/shared/kernel/ask"
	"huijing_mall/shared/kernel/hmErrors"
	"huijing_mall/variable"

	"net/http"

	"github.com/beego/beego/v2/core/logs"
	"github.com/bytedance/sonic"
	"github.com/gin-gonic/gin"
)

// 获取地区数据
func GetAreaData(c *gin.Context) {
	dbs := get_ctx_value.GetDBS(c)
	var a ask.AreaCodeRequest
	if err := c.BindJSON(&a); err != nil {
		// 如果解析失败，返回错误
		ask.Errors(c, http.StatusBadRequest, err)
		return
	}
	data, err := collectlogic.FindAllData(&dbs, a.Address)
	if err != nil {
		// 如果解析失败，返回错误
		ask.Errors(c, http.StatusBadRequest, err)
		return
	}
	ask.Success(c, data)
	return
}

// 获取地区数据 （携带rod）
func GetCityData(c *gin.Context) {
	userID := c.MustGet("userID").(uint)
	if userID != 0 {
		var cd ask.CityDBRequest
		if err := c.BindJSON(&cd); err != nil {
			ask.Errors(c, http.StatusBadRequest, err)
			return
		}
		dbs := get_ctx_value.GetDBS(c)
		//variable.IsDB = &cd.IsDB
		//if cd.IsDB == "true" {
		//var (
		//	MysqlErr error
		//	RedisErr error
		//)
		//variable.DB, MysqlErr = database.InitMysql()
		//if MysqlErr != nil {
		//	common.Success(g, map[string]interface{}{"message": MysqlErr.Error(), "code": -1, "data": nil})
		//	return
		//}
		//variable.Rdb, RedisErr = database.InitRedis()
		//if RedisErr != nil {
		//	common.Success(g, map[string]interface{}{"message": RedisErr.Error(), "code": -1, "data": nil})
		//	return
		//}
		//} else {
		//	err := common.ParseSQLToMap("area.sql")
		//	if err != nil {
		//		common.Success(g, map[string]interface{}{"message": err.Error(), "code": -1, "data": nil})
		//		return
		//	}
		//}
		err, i, b := collectlogic.GetData(&dbs, cd)
		if err != nil {
			ask.Errors(c, http.StatusBadRequest, err)
			return
		}
		if i != nil {
			logger.Info(fmt.Sprintf("调试 - i 的类型: %T, ", i)) // 重要调试信息
			if value, ok := i.([]models.SelectBoss); ok {
				variable.DataKey = common.StrPinJie(cd.WorkCity, cd.WorkType)
				dataKey := common.StrPinJie(common.IntToStr(int(userID)), "_", variable.DataKey)
				if !cachebase.RedisExist(dbs.Rdb, dataKey) {
					cachebase.RedisSet(dbs.Rdb, dataKey, value)
				}
				ask.Success(c, value)
				return
			}
		}
		if !b {
			logger.Info("压入队列")
			marshal, _ := sonic.Marshal(cd)

			if err = dbs.Mq.Publish(variable.TaskQu, []byte(variable.My_zset+"_"+string(marshal))); err != nil {
				logger.Info(fmt.Sprintf("发送消息到 %s 失败: %v", variable.TaskQu, err))
			} else {
				logger.Info(fmt.Sprintf("已发送消息到 %s: %s", variable.TaskQu, variable.My_zset+"_"+string(marshal)))
			}
			// 添加元素到有序集合
			//marshal, _ := sonic.Marshal(cd)
			//err = cachebase.AddToZSetWithDefaultScore(dbs.Rdb, variable.My_zset, string(marshal))
			//if err != nil {
			//	ask.Errors(c, http.StatusInternalServerError, hmErrors.ErrSystem("系统内部错误,请稍后再试."))
			//	return
			//}
			ask.Errors(c, 200, hmErrors.ErrMsg("数据需重新采集，请等待"))
			return
		}
	}
}

// 获取地区数据 （携带rod）
func SetScore(g *gin.Context) {
	var cd ask.SetScoreReq
	if err := g.BindJSON(&cd); err != nil {
		// 如果解析失败，返回错误
		ask.Errors(g, http.StatusBadRequest, err)
		return
	}
	dbs := g.MustGet(variable.DBS).(*get_ctx_value.DBS)
	js, _ := sonic.Marshal(cd)
	var pm ask.CityDBRequest
	sonic.Unmarshal(js, &pm)
	jspm, _ := sonic.Marshal(pm)
	err := cachebase.AddToZSet(dbs.Rdb, variable.My_zset, string(jspm), common.StrToFloat(cd.Score))
	if err != nil {
		fmt.Println("Failed to add task3:", err)
		return
	}
	ask.Success(g, nil)
	return
}

// 删除数据
func DelBrandData(g *gin.Context) {
	dbs := g.MustGet(variable.DBS).(*get_ctx_value.DBS)
	var b ask.BrandReq
	if err := g.BindJSON(&b); err != nil {
		// 如果解析失败，返回错误
		ask.Errors(g, http.StatusBadRequest, err)
		return
	}
	if collectlogic.Del(dbs, b.BrandName) {
		ask.Success(g, nil)
		return
	} else {
		ask.Success(g, nil)
		return
	}

}

// 获取 任务
func QueryTask(g *gin.Context) {
	dbs := g.MustGet(variable.DBS).(*get_ctx_value.DBS)
	var t ask.TaskReq
	if err := g.BindJSON(&t); err != nil {
		// 如果解析失败，返回错误
		ask.Errors(g, http.StatusBadRequest, err)
		return
	}
	logs.Info("参数：" + t.TaskName + t.TaskKey)
	res, err := collectlogic.QueryTasks(dbs, t.TaskName, t.TaskKey)
	data, _ := sonic.Marshal(res)
	logs.Info("请求成功：[data]" + string(data))
	if err != nil || res.TaskName == "" {
		ask.Errors(g, 200, hmErrors.ErrMsg("查询错误或者无此任务"))
		return
	} else {
		ask.Success(g, res)
		return
	}

}

// 获取 任务
func CreatTask(g *gin.Context) {
	var t ask.TaskReq
	if err := g.BindJSON(&t); err != nil {
		// 如果解析失败，返回错误
		ask.Errors(g, http.StatusBadRequest, err)
		return
	}
	ask.Errors(g, 200, hmErrors.ErrMsg("暂未开放,请耐心等待"))
	return
}

// 获取 任务
func GetTask(g *gin.Context) {
	dbs := g.MustGet(variable.DBS).(*get_ctx_value.DBS)
	ask.Errors(g, 200, hmErrors.ErrMsg("暂未开放,请耐心等待"))
	return
	var t ask.TaskReq
	if err := g.BindJSON(&t); err != nil {
		// 如果解析失败，返回错误
		ask.Errors(g, http.StatusBadRequest, err)
		return
	}
	// 获取有序集合中的元素（按优先级升序）
	tasks, err := cachebase.GetZSetRange(dbs.Rdb, variable.My_zset, 0, -1)
	if err != nil {
		fmt.Println("Failed to get tasks:", err)
		return
	}

	var cb ask.CityDBRequest
	for _, v := range tasks {
		sonic.Unmarshal([]byte(v), &cb)
	}
	_, _, _ = collectlogic.FindOne(dbs, cb)
	ask.Errors(g, 200, hmErrors.ErrMsg("暂未开放,请耐心等待"))
	return
}

// 结束 任务
func EndTask(g *gin.Context) {
	dbs := g.MustGet(variable.DBS).(*get_ctx_value.DBS)
	var t ask.TaskReq
	if err := g.BindJSON(&t); err != nil {
		// 如果解析失败，返回错误
		ask.Errors(g, http.StatusBadRequest, err)
		return
	}
	ask.Errors(g, 200, hmErrors.ErrMsg("暂未开放,请耐心等待"))
	return
	endTask, err := collectlogic.EndTasks(dbs, t.TaskName, t.TaskKey)
	if err != nil {
		ask.Errors(g, http.StatusBadRequest, err)
		return
	}
	fmt.Println(endTask)
	//if controllers.QueryTask(db, t.TaskName) {
	ask.Success(g, nil)
	return

}

// 获取 任务
func Notify(g *gin.Context) {
	var t models.Task
	if err := g.BindJSON(&t); err != nil {
		// 如果解析失败，返回错误
		ask.Errors(g, http.StatusBadRequest, err)
		return
	}
	ask.Errors(g, 200, hmErrors.ErrMsg("暂未开放,请耐心等待"))
}

// 添加地区 code
func InsertArea(g *gin.Context) {
	dbs := g.MustGet(variable.DBS).(*get_ctx_value.DBS)
	//var ct data_models.PmCity
	// 尝试将JSON绑定到form变量
	cityName := g.Query("cityName")
	cityCode := g.Query("cityCode")
	//if err := g.BindJSON(&ct); err != nil {
	//	common.Success(g, map[string]interface{}{"message": err.Error(), "code": -1})
	//	return
	//}
	err := collectlogic.InsertCity(dbs, cityName, cityCode)
	if err != nil {
		ask.Errors(g, http.StatusBadRequest, err)
		return
	}
	ask.Success(g, nil)
	return
}
